The PEP in question adds support for putting "list splats" (*x) inside list/set comprehensions and generator expressions (so, [*x for x in xs] and likewise with curly braces and parentheses), and similarly a "dictionary splat" **d inside dictionary comprehensions {**d for d in ds}.

The actual tree-sitter-python support for this is fairly straightforward -- we just have to allow list_splat and dictionary_splat nodes in the appropriate places.

The difficulty comes when we have to transform the tree-sitter AST into a Python AST. Comprehensions are one of a few instances in the Python extractor where we actually desugar the syntax into a simpler form. Thus, for something like [x + 1 for x in xs], the code that is actually emitted is roughly similar to

def _listcomp(it):
    for x in it:
        yield x + 1
list(_listcomp(xs))

In reality, we never materialise the function separately -- rather it lives as a child of a ListComp / SetComp / DictComp / GenExpr node (which would replace the list call above). Also the parameter it is called .0 -- an otherwise impossible parameter name -- to make it stand out in the AST.

Now, the semantics of [*x for x in xs] is that we treat x as an iterable in its own right, and yield all of its elements in turn. This is exactly what yield from does in Python, so what we could do is simply use yield from in the desugaring in this case.

Thus, something like [*reversed(x) for x in xs] would become

def _listcomp(it):
    for x in it:
        yield from reversed(x)
list(_listcomp(xs))

A similar scheme applies to set comprehensions and generator expressions.

For dictionary comprehensions, the setup is slightly different. Here, the current desugaring of {k: v for k, v in ts} (say) is

def _dictcomp(it):
    for k, v in it:
        yield (k, v)
dict(_dictcomp(ts))

That is, we pass out the elements of the dictionary comprehension as key-value tuples.

For {**d for d in ds}, then, we can do a similar yield from desugaring to the one above, but we need a bit more to get the yielded values to be tuples:

def _dictcomp(it):
    for d in it:
        yield from d.items()
dict(_dictcomp(ts))

The plus side of all of this fiddly business is that we don't have to define any specific control-flow/data-flow for these new constructs. We get all of that for free.

Finally, we fix a bug that was present in the old parser (and dutifully recreated in the new): for some reason we were yielding (value, key) tuples rather than (key, value).